package com.gmscosmo.request;

public class CreateStreamBody extends JanusRequestBody {
    private Integer id;//streamId
    /**
     * rtp|live|ondemand|rtsp
     * rtp = stream originated by an external tool (e.g., gstreamer or
     * ffmpeg) and sent to the plugin via RTP
     * live = local file streamed live to multiple viewers
     * (multiple viewers = same streaming context)
     * ondemand = local file streamed on-demand to a single listener
     * (multiple viewers = different streaming contexts)
     * rtsp = stream originated by an external RTSP feed (only
     * available if libcurl support was compiled)
     **/
    private String type;
    /**
     * This is my awesome stream
     */
    private String description;
    /**
     *  An optional string that can contain any metadata (e.g., JSON)associated with the stream you want users to receive
     */
    private String metadata;
    /**
     * true|false (private streams don't appear when you do a 'list' request)
     */
    private Boolean is_private;
    /**
     * path to the local file to stream (only for live/ondemand)
     */
    private String filename;
    /**
     * <optional password needed for manipulating (e.g., destroying or enabling/disabling) the stream>
     */
    private String secret;
    /**
     * <optional password needed for watching the stream>
     */
    private String pin;
    /**
     * true|false (do/don't stream audio)
     */
    private Boolean audio;
    /**
     * true|false (do/don't stream video)The following options are only valid for the 'rtp' type:
     */
    private Boolean video;
    /**
     * true|false (do/don't stream text via datachannels)
     */
    private Boolean data;
    /**
     * local port for receiving audio frames
     */
    private Integer audioport;
    /**
     * local port for receiving and sending audio RTCP feedback
     */
    private String audiortcpport;
    /**
     * multicast group for receiving audio frames, if any
     */
    private String audiomcast;
    /**
     * network interface or IP address to bind to, if any (binds to all otherwise)
     */
    private String audioiface;
    /**
     * <audio RTP payload type> (e.g., 111)
     */
    private Integer audiopt = 111;
    /**
     *  RTP map of the audio codec (e.g., opus/48000/2)
     */
    private String audiortpmap = "opus/48000/2";
    /**
     * Codec specific parameters, if any
     */
    private String audiofmtp;
    /**
     * true|false (whether the plugin should perform skew analisys and compensation on incoming audio RTP stream, EXPERIMENTAL)
     */
    private String audioskew;
    /**
     * local port for receiving video frames (only for rtp)
     */
    private Integer videoport;
    /**
     * local port for receiving and sending video RTCP feedback
     */
    private Integer videortcpport;
    /**
     *  multicast group for receiving video frames, if any
     */
    private String videomcast;
    /**
     * network interface or IP address to bind to, if any (binds to all otherwise)
     */
    private String videoiface;
    /**
     * <video RTP payload type> (e.g., 100)
     */
    private Integer videopt = 96;
    /**
     * // RTP map of the video codec (e.g., VP8/90000)
     */
    private String videortpmap = "VP8/90000";
    /**
     * Codec specific parameters, if any
     */
    private String videofmtp;
    /**
     *  true|false (whether the plugin should store the latestkeyframe and send it immediately for new viewers, EXPERIMENTAL)
     */
    private Boolean videobufferkf=true;
    /**
     * true|false (do|don't enable video simulcasting)
     */
    private Boolean videosimulcast;
    /**
     * second local port for receiving video frames (only for rtp, and simulcasting)
     */
    private Integer videoport2;
    /**
     * third local port for receiving video frames (only for rtp, and simulcasting)
     */
    private Integer videoport3;
    /**
     * true|false (whether the plugin should perform skew analisys and compensation on incoming video RTP stream, EXPERIMENTAL)
     */
    private Boolean videoskew;
    /**
     * true|false (whether the video will have SVC support; works only for VP9-SVC, default; //false)
     */
    private Boolean videosvc;
    /**
     * in case of collision (more than one SSRC hitting the same port),
     * the plugin will discard incoming RTP packets with a new SSRC unless this many milliseconds passed,
     * which would then change the current SSRC (0=disabled)
     */
    private String collision;
    /**
     * local port for receiving data messages to relay
     */
    private String dataport;
    /**
     * multicast group for receiving data messages, if any
     */
    private String datamcast;
    /**
     * network interface or IP address to bind to, if any (binds to all otherwise)
     */
    private String dataiface;
    /**
     * text|binary (type of data this mountpoint will relay, default=text)
     */
    private String datatype;
    /**
     * true|false (whether the plugin should store the latest message and send it immediately for new viewers)
     */
    private Boolean databuffermsg;
    /**
     * number of threads to assist with the relaying part, which can help
     * if you expect a lot of viewers that may cause the RTP receiving part in the Streaming plugin to slow down and fail to catch up (default=0)
     * In case you want to use SRTP for your RTP-based mountpoint, you'll need
     * to configure the SRTP-related properties as well, namely the suite to
     * use for hashing (32 or 80) and the crypto information for decrypting
     * the stream (as a base64 encoded string the way SDES does it). Notice
     * that with SRTP involved you'll have to pay extra attention to what you
     * feed the mountpoint, as you may risk getting SRTP decrypt errors:
     **/
    private Integer threads;
    private Integer srtpsuite;// 32;
    private String srtpcrypto;// "WbTBosdVUZqEb6Htqhn+m3z7wUh4RJVR8nE15GbN";
    /**
     * WbTBosdVUZqEb6Htqhn+m3z7wUh4RJVR8nE15GbN
     * <p>
     * The Streaming plugin can also be used to (re)stream media that has been
     * encrypted using something that can be consumed via Insertable Streams.
     * In that case, we only need to be aware of it, so that we can send the
     * info along with the SDP. How to decrypt the media is out of scope, and
     * up to the application since, again, this is end-to-end encryption and
     * so neither Janus nor the Streaming plugin have access to anything.
     * DO NOT SET THIS PROPERTY IF YOU DON'T KNOW WHAT YOU'RE DOING!
     */
    private Boolean e2ee;// true;
    /**
     * The following options are only valid for the 'rtsp' type:
     */
    private String url; // RTSP stream URL
    private String rtsp_user; // RTSP authorization username, if needed
    private String rtsp_pwd; // RTSP authorization password, if needed
    /**
     * whether an error should be returned if connecting to the RTSP server fails (default=true)
     */
    private Boolean rtsp_failcheck;
    /**
     * network interface IP address or device name to listen on when receiving RTSP streams
     */
    private String rtspiface;
    /**
     * after n seconds passed and no media assumed, the RTSP server has gone and schedule a reconnect (default=5s)
     */
    private Integer rtsp_reconnect_delay;
    /**
     * by default the streaming plugin will check the RTSP connection with an OPTIONS query,
     * the value of the timeout comes from the RTSP session initializer and by default
     * this session timeout is the half of this value In some cases this value can be too high (for example more than one minute)
     * because of the media server. In that case this plugin will calculate the timeout with this
     * formula: timeout = min(session_timeout, rtsp_session_timeout / 2). (default=0s)
     **/
    private Integer rtsp_session_timeout;
    /**
     * communication timeout (CURLOPT_TIMEOUT) for cURL call gathering the RTSP information (default; //10s)
     */
    private Integer rtsp_timeout;
    /**
     * connection timeout for cURL (CURLOPT_CONNECTTIMEOUT) call gathering the RTSP information (default; //5s)
     */
    private Integer rtsp_conn_timeout;

    public CreateStreamBody(){

    }
    public CreateStreamBody(String request){
        super(request);
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getMetadata() {
        return metadata;
    }

    public void setMetadata(String metadata) {
        this.metadata = metadata;
    }

    public Boolean getIs_private() {
        return is_private;
    }

    public void setIs_private(Boolean is_private) {
        this.is_private = is_private;
    }

    public String getFilename() {
        return filename;
    }

    public void setFilename(String filename) {
        this.filename = filename;
    }

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public String getPin() {
        return pin;
    }

    public void setPin(String pin) {
        this.pin = pin;
    }

    public Boolean getAudio() {
        return audio;
    }

    public void setAudio(Boolean audio) {
        this.audio = audio;
    }

    public Boolean getVideo() {
        return video;
    }

    public void setVideo(Boolean video) {
        this.video = video;
    }

    public Boolean getData() {
        return data;
    }

    public void setData(Boolean data) {
        this.data = data;
    }

    public Integer getAudioport() {
        return audioport;
    }

    public void setAudioport(Integer audioport) {
        this.audioport = audioport;
    }

    public String getAudiortcpport() {
        return audiortcpport;
    }

    public void setAudiortcpport(String audiortcpport) {
        this.audiortcpport = audiortcpport;
    }

    public String getAudiomcast() {
        return audiomcast;
    }

    public void setAudiomcast(String audiomcast) {
        this.audiomcast = audiomcast;
    }

    public String getAudioiface() {
        return audioiface;
    }

    public void setAudioiface(String audioiface) {
        this.audioiface = audioiface;
    }

    public Integer getAudiopt() {
        return audiopt;
    }

    public void setAudiopt(Integer audiopt) {
        this.audiopt = audiopt;
    }

    public String getAudiortpmap() {
        return audiortpmap;
    }

    public void setAudiortpmap(String audiortpmap) {
        this.audiortpmap = audiortpmap;
    }

    public String getAudiofmtp() {
        return audiofmtp;
    }

    public void setAudiofmtp(String audiofmtp) {
        this.audiofmtp = audiofmtp;
    }

    public String getAudioskew() {
        return audioskew;
    }

    public void setAudioskew(String audioskew) {
        this.audioskew = audioskew;
    }

    public Integer getVideoport() {
        return videoport;
    }

    public void setVideoport(Integer videoport) {
        this.videoport = videoport;
    }

    public Integer getVideortcpport() {
        return videortcpport;
    }

    public void setVideortcpport(Integer videortcpport) {
        this.videortcpport = videortcpport;
    }

    public String getVideomcast() {
        return videomcast;
    }

    public void setVideomcast(String videomcast) {
        this.videomcast = videomcast;
    }

    public String getVideoiface() {
        return videoiface;
    }

    public void setVideoiface(String videoiface) {
        this.videoiface = videoiface;
    }

    public Integer getVideopt() {
        return videopt;
    }

    public void setVideopt(Integer videopt) {
        this.videopt = videopt;
    }

    public String getVideortpmap() {
        return videortpmap;
    }

    public void setVideortpmap(String videortpmap) {
        this.videortpmap = videortpmap;
    }

    public String getVideofmtp() {
        return videofmtp;
    }

    public void setVideofmtp(String videofmtp) {
        this.videofmtp = videofmtp;
    }

    public Boolean getVideobufferkf() {
        return videobufferkf;
    }

    public void setVideobufferkf(Boolean videobufferkf) {
        this.videobufferkf = videobufferkf;
    }

    public Boolean getVideosimulcast() {
        return videosimulcast;
    }

    public void setVideosimulcast(Boolean videosimulcast) {
        this.videosimulcast = videosimulcast;
    }

    public Integer getVideoport2() {
        return videoport2;
    }

    public void setVideoport2(Integer videoport2) {
        this.videoport2 = videoport2;
    }

    public Integer getVideoport3() {
        return videoport3;
    }

    public void setVideoport3(Integer videoport3) {
        this.videoport3 = videoport3;
    }

    public Boolean getVideoskew() {
        return videoskew;
    }

    public void setVideoskew(Boolean videoskew) {
        this.videoskew = videoskew;
    }

    public Boolean getVideosvc() {
        return videosvc;
    }

    public void setVideosvc(Boolean videosvc) {
        this.videosvc = videosvc;
    }

    public String getCollision() {
        return collision;
    }

    public void setCollision(String collision) {
        this.collision = collision;
    }

    public String getDataport() {
        return dataport;
    }

    public void setDataport(String dataport) {
        this.dataport = dataport;
    }

    public String getDatamcast() {
        return datamcast;
    }

    public void setDatamcast(String datamcast) {
        this.datamcast = datamcast;
    }

    public String getDataiface() {
        return dataiface;
    }

    public void setDataiface(String dataiface) {
        this.dataiface = dataiface;
    }

    public String getDatatype() {
        return datatype;
    }

    public void setDatatype(String datatype) {
        this.datatype = datatype;
    }

    public Boolean getDatabuffermsg() {
        return databuffermsg;
    }

    public void setDatabuffermsg(Boolean databuffermsg) {
        this.databuffermsg = databuffermsg;
    }

    public Integer getThreads() {
        return threads;
    }

    public void setThreads(Integer threads) {
        this.threads = threads;
    }

    public Integer getSrtpsuite() {
        return srtpsuite;
    }

    public void setSrtpsuite(Integer srtpsuite) {
        this.srtpsuite = srtpsuite;
    }

    public String getSrtpcrypto() {
        return srtpcrypto;
    }

    public void setSrtpcrypto(String srtpcrypto) {
        this.srtpcrypto = srtpcrypto;
    }

    public Boolean getE2ee() {
        return e2ee;
    }

    public void setE2ee(Boolean e2ee) {
        this.e2ee = e2ee;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getRtsp_user() {
        return rtsp_user;
    }

    public void setRtsp_user(String rtsp_user) {
        this.rtsp_user = rtsp_user;
    }

    public String getRtsp_pwd() {
        return rtsp_pwd;
    }

    public void setRtsp_pwd(String rtsp_pwd) {
        this.rtsp_pwd = rtsp_pwd;
    }

    public Boolean getRtsp_failcheck() {
        return rtsp_failcheck;
    }

    public void setRtsp_failcheck(Boolean rtsp_failcheck) {
        this.rtsp_failcheck = rtsp_failcheck;
    }

    public String getRtspiface() {
        return rtspiface;
    }

    public void setRtspiface(String rtspiface) {
        this.rtspiface = rtspiface;
    }

    public Integer getRtsp_reconnect_delay() {
        return rtsp_reconnect_delay;
    }

    public void setRtsp_reconnect_delay(Integer rtsp_reconnect_delay) {
        this.rtsp_reconnect_delay = rtsp_reconnect_delay;
    }

    public Integer getRtsp_session_timeout() {
        return rtsp_session_timeout;
    }

    public void setRtsp_session_timeout(Integer rtsp_session_timeout) {
        this.rtsp_session_timeout = rtsp_session_timeout;
    }

    public Integer getRtsp_timeout() {
        return rtsp_timeout;
    }

    public void setRtsp_timeout(Integer rtsp_timeout) {
        this.rtsp_timeout = rtsp_timeout;
    }

    public Integer getRtsp_conn_timeout() {
        return rtsp_conn_timeout;
    }

    public void setRtsp_conn_timeout(Integer rtsp_conn_timeout) {
        this.rtsp_conn_timeout = rtsp_conn_timeout;
    }

}
